<?php
declare (strict_types = 1);

namespace app\common;

use think\facade\Request;
use think\facade\Db;

/**
 * 数据权限助手类
 * 提供统一的数据权限验证和查询条件构建
 */
class DataPermissionHelper
{
    /**
     * 获取当前用户的数据权限信息
     * @return array|null
     */
    public static function getCurrentUserPermissions()
    {
        // 🚨🚨🚨 修复：中间件中存储的是 'dataPermissions' 而不是 'data_permissions' 🚨🚨🚨
        return Request::middleware('dataPermissions');
    }
    
    /**
     * 获取当前用户ID
     * @return int
     */
    public static function getCurrentUserId()
    {
        // 🚨🚨🚨 修复：中间件中存储的是 'userId' 而不是 'user_id' 🚨🚨🚨
        return (int)(Request::middleware('userId') ?? 0);
    }
    
    /**
     * 获取当前用户信息
     * @return array|null
     */
    public static function getCurrentUserInfo()
    {
        return Request::middleware('user_info');
    }
    
    /**
     * 检查是否为超级管理员
     * @return bool
     */
    public static function isSuperAdmin()
    {
        $permissions = self::getCurrentUserPermissions();
        return $permissions['is_super_admin'] ?? false;
    }
    
    /**
     * 构建个人数据权限查询条件
     * 用户只能查看/操作自己创建的数据 (belong_uid)
     * @param array $baseWhere 基础查询条件
     * @return array
     */
    public static function buildPersonalDataWhere($baseWhere = [])
    {
        $userId = self::getCurrentUserId();
        if ($userId <= 0) {
            return $baseWhere;
        }
        
        // 超级管理员拥有所有权限
        if (self::isSuperAdmin()) {
            return $baseWhere;
        }
        
        // 添加个人数据权限条件
        $where = $baseWhere;
        $where[] = ['belong_uid', '=', $userId];
        
        return $where;
    }
    
    /**
     * 构建部门数据权限查询条件
     * 用户可以查看/操作本部门及下级部门的数据 (belong_did)
     * @param array $baseWhere 基础查询条件
     * @return array
     */
    public static function buildDepartmentDataWhere($baseWhere = [])
    {
        $permissions = self::getCurrentUserPermissions();
        if (!$permissions) {
            return $baseWhere;
        }
        
        // 超级管理员拥有所有权限
        if ($permissions['is_super_admin']) {
            return $baseWhere;
        }
        
        // 收集用户有权限的部门ID
        $allowedDeptIds = [];
        
        // 1. 用户自己的部门
        if ($permissions['department_id'] > 0) {
            $allowedDeptIds[] = $permissions['department_id'];
        }
        
        // 2. 用户作为领导的部门
        $allowedDeptIds = array_merge($allowedDeptIds, $permissions['leader_departments']);
        
        // 3. 用户管理的下级部门
        $allowedDeptIds = array_merge($allowedDeptIds, $permissions['subordinate_departments']);
        
        // 去重
        $allowedDeptIds = array_unique($allowedDeptIds);
        
        if (empty($allowedDeptIds)) {
            // 如果没有部门权限，返回一个永远不满足的条件
            $where = $baseWhere;
            $where[] = ['belong_did', '=', -1];
            return $where;
        }
        
        // 添加部门数据权限条件
        $where = $baseWhere;
        $where[] = ['belong_did', 'in', $allowedDeptIds];
        
        return $where;
    }
    
    /**
     * 构建共享数据权限查询条件
     * 用户可以查看/操作共享给自己的数据 (share_ids)
     * @param array $baseWhere 基础查询条件
     * @return array
     */
    public static function buildSharedDataWhere($baseWhere = [])
    {
        $userId = self::getCurrentUserId();
        if ($userId <= 0) {
            return $baseWhere;
        }
        
        // 超级管理员拥有所有权限
        if (self::isSuperAdmin()) {
            return $baseWhere;
        }
        
        // 添加共享数据权限条件
        $where = $baseWhere;
        $where[] = ['', 'exp', Db::raw("FIND_IN_SET('{$userId}', c.share_ids)")];
        
        return $where;
    }
    
    /**
     * 构建审批数据权限查询条件
     * 用户可以查看/操作需要自己审批的数据 (check_uids)
     * @param array $baseWhere 基础查询条件
     * @return array
     */
    public static function buildApprovalDataWhere($baseWhere = [])
    {
        $userId = self::getCurrentUserId();
        if ($userId <= 0) {
            return $baseWhere;
        }
        
        // 超级管理员拥有所有权限
        if (self::isSuperAdmin()) {
            return $baseWhere;
        }
        
        // 添加审批数据权限条件
        $where = $baseWhere;
        $where[] = ['', 'exp', Db::raw("FIND_IN_SET('{$userId}', check_uids)")];
        
        return $where;
    }
    
    /**
     * 构建综合数据权限查询条件 (OR条件)
     * 用户可以查看满足以下任一条件的数据：
     * 1. 自己创建的数据 (belong_uid)
     * 2. 本部门或下级部门的数据 (belong_did)
     * 3. 共享给自己的数据 (share_ids)
     * 4. 需要自己审批的数据 (check_uids)
     * 5. 自己录入的数据 (admin_id) - 新增录入人权限
     * @param array $baseWhere 基础查询条件
     * @param array $options 权限选项，可控制启用哪些权限类型
     * @return array
     */
    public static function buildComprehensiveDataWhere($baseWhere = [], $options = [])
    {
        $userId = self::getCurrentUserId();
        $permissions = self::getCurrentUserPermissions();
        
        if ($userId <= 0 || !$permissions) {
            return $baseWhere;
        }
        
        // 超级管理员拥有所有权限
        if ($permissions['is_super_admin']) {
            return $baseWhere;
        }
        
        // 默认启用所有权限类型
        $defaultOptions = [
            'personal' => true,     // 个人数据权限
            'department' => true,   // 部门数据权限
            'shared' => true,       // 共享数据权限
            'approval' => true,     // 审批数据权限
            'creator' => true       // 录入人权限 - 新增
        ];
        $options = array_merge($defaultOptions, $options);
        
        $whereOr = [];

        // 1. 个人数据权限
        if ($options['personal']) {
            $whereOr[] = ['c.belong_uid', '=', $userId];
        }

        // 2. 部门数据权限
        if ($options['department']) {
            $allowedDeptIds = [];

            // 用户自己的部门
            if ($permissions['department_id'] > 0) {
                $allowedDeptIds[] = $permissions['department_id'];
            }

            // 用户作为领导的部门
            $allowedDeptIds = array_merge($allowedDeptIds, $permissions['leader_departments']);

            // 用户管理的下级部门
            $allowedDeptIds = array_merge($allowedDeptIds, $permissions['subordinate_departments']);

            // 去重
            $allowedDeptIds = array_unique($allowedDeptIds);

            if (!empty($allowedDeptIds)) {
                $whereOr[] = ['c.belong_did', 'in', $allowedDeptIds];
            }
        }

        // 3. 共享数据权限
        if ($options['shared']) {
            $whereOr[] = ['', 'exp', Db::raw("FIND_IN_SET('{$userId}', c.share_ids)")];
        }

        // 4. 审批数据权限
        if ($options['approval']) {
            $whereOr[] = ['', 'exp', Db::raw("FIND_IN_SET('{$userId}', c.check_uids)")];
        }

        // 5. 录入人权限 - 新增
        if ($options['creator']) {
            $whereOr[] = ['c.admin_id', '=', $userId];
        }

        if (empty($whereOr)) {
            // 如果没有任何权限，返回一个永远不满足的条件
            $where = $baseWhere;
            $where[] = ['c.id', '=', -1];
            return $where;
        }
        
        // 组合基础条件和权限条件
        $where = $baseWhere;
        $where[] = function ($query) use ($whereOr) {
            $query->whereOr($whereOr);
        };
        
        return $where;
    }
    
    /**
     * 检查用户是否有权限访问指定数据
     * @param string $table 数据表名
     * @param int $dataId 数据ID
     * @param array $options 权限选项
     * @return bool
     */
    public static function checkDataAccess($table, $dataId, $options = [])
    {
        if ($dataId <= 0) {
            return false;
        }
        
        // 超级管理员拥有所有权限
        if (self::isSuperAdmin()) {
            return true;
        }
        
        try {
            // 查询数据是否存在且用户有权限访问
            // 构建通用条件，不包含表别名
            $baseWhere = [['id', '=', $dataId]];

            // 获取用户ID和权限
            $userId = self::getCurrentUserId();
            $permissions = self::getCurrentUserPermissions();

            if ($userId <= 0 || !$permissions) {
                return false;
            }

            // 默认启用所有权限类型（但客户表不使用审批权限）
            $defaultOptions = [
                'personal' => true,     // 个人数据权限
                'department' => true,   // 部门数据权限
                'shared' => true,       // 共享数据权限
                'approval' => ($table !== 'customer'),  // 审批数据权限（客户表无此字段）
                'creator' => true       // 录入人权限 - 新增
            ];
            $options = array_merge($defaultOptions, $options);

            // 为customer表添加表别名以避免列名歧义
            $tableAlias = '';
            if ($table === 'customer') {
                $tableAlias = ' c';
                // 更新baseWhere，添加表别名
                $baseWhere = [['c.id', '=', $dataId]];
            }
            
            $whereOr = [];

            // 1. 个人数据权限
            if ($options['personal']) {
                $field = $tableAlias ? 'c.belong_uid' : 'belong_uid';
                $whereOr[] = [$field, '=', $userId];
            }

            // 2. 部门数据权限
            if ($options['department']) {
                $allowedDeptIds = [];

                // 用户自己的部门
                if ($permissions['department_id'] > 0) {
                    $allowedDeptIds[] = $permissions['department_id'];
                }

                // 用户作为领导的部门
                $allowedDeptIds = array_merge($allowedDeptIds, $permissions['leader_departments']);

                // 用户管理的下级部门
                $allowedDeptIds = array_merge($allowedDeptIds, $permissions['subordinate_departments']);

                // 去重
                $allowedDeptIds = array_unique($allowedDeptIds);

                if (!empty($allowedDeptIds)) {
                    $field = $tableAlias ? 'c.belong_did' : 'belong_did';
                    $whereOr[] = [$field, 'in', $allowedDeptIds];
                }
            }

            // 3. 共享数据权限
            if ($options['shared']) {
                $field = $tableAlias ? 'c.share_ids' : 'share_ids';
                $whereOr[] = ['', 'exp', Db::raw("FIND_IN_SET('{$userId}', {$field})")];
            }

            // 4. 审批数据权限
            if ($options['approval']) {
                $field = $tableAlias ? 'c.check_uids' : 'check_uids';
                $whereOr[] = ['', 'exp', Db::raw("FIND_IN_SET('{$userId}', {$field})")];
            }

            // 5. 录入人权限 - 新增
            if ($options['creator']) {
                $field = $tableAlias ? 'c.admin_id' : 'admin_id';
                $whereOr[] = [$field, '=', $userId];
            }
            
            if (empty($whereOr)) {
                return false;
            }
            
            // 组合基础条件和权限条件
            // 使用table函数并添加表别名以避免列名歧义
            $query = Db::table($table . $tableAlias)
                ->where($baseWhere)
                ->whereOr(function ($query) use ($whereOr) {
                    foreach ($whereOr as $condition) {
                        if (is_array($condition) && count($condition) === 3) {
                            $query->whereOr($condition[0], $condition[1], $condition[2]);
                        } else {
                            $query->whereOr($condition);
                        }
                    }
                });
            $count = $query->count();

            return $count > 0;
        } catch (\Exception $e) {
            return false;
        }
    }
    
    /**
     * 检查用户是否有权限修改指定数据
     * @param string $table 数据表名
     * @param int $dataId 数据ID
     * @return bool
     */
    public static function checkDataEditAccess($table, $dataId)
    {
        if ($dataId <= 0) {
            return false;
        }
        
        $userId = self::getCurrentUserId();
        if ($userId <= 0) {
            return false;
        }
        
        // 超级管理员拥有所有权限
        if (self::isSuperAdmin()) {
            return true;
        }
        
        try {
            // 对于修改权限，通常只允许数据创建者或有审批权限的用户修改
            $data = Db::name($table)->where('id', $dataId)->find();
            if (!$data) {
                return false;
            }
            
            // 1. 数据创建者可以修改
            if (isset($data['belong_uid']) && $data['belong_uid'] == $userId) {
                return true;
            }
            
            // 2. 有审批权限的用户可以修改
            if (isset($data['check_uids']) && !empty($data['check_uids'])) {
                $checkUids = explode(',', $data['check_uids']);
                if (in_array($userId, $checkUids)) {
                    return true;
                }
            }
            
            return false;
        } catch (\Exception $e) {
            return false;
        }
    }
    
    /**
     * 从 oa_data_auth 表检查用户是否有特定权限
     * @param string $permissionName 权限名称，如 'legal_view_all_customers'
     * @param int $userId 用户ID，默认当前用户
     * @return bool
     */
    public static function checkDataAuthPermission($permissionName, $userId = null)
    {
        if ($userId === null) {
            $userId = self::getCurrentUserId();
        }

        if ($userId <= 0) {
            return false;
        }

        try {
            // 查询权限配置
            $auth = Db::name('data_auth')
                ->where('name', $permissionName)
                ->where('module', 'customer')
                ->find();

            if (!$auth) {
                return false;
            }

            // 检查用户ID是否在权限列表中
            $uids = trim($auth['uids'], ',');
            if (empty($uids)) {
                return false;
            }

            $uidArray = explode(',', $uids);
            return in_array((string)$userId, $uidArray);
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * 检查用户是否有法务部门特殊权限
     * @param string $permission view, edit, create
     * @return bool
     */
    public static function hasLegalDepartmentPermission($permission)
    {
        // 超级管理员拥有所有权限
        if (self::isSuperAdmin()) {
            return true;
        }

        // 映射权限名称
        $permissionMap = [
            'view' => 'legal_view_all_customers',
            'edit' => 'legal_edit_all_customers',
            'create' => 'legal_create_customer'
        ];

        if (!isset($permissionMap[$permission])) {
            return false;
        }

        return self::checkDataAuthPermission($permissionMap[$permission]);
    }

    /**
     * 检查用户是否有部门负责人权限
     * @param string $permission create
     * @return bool
     */
    public static function hasDepartmentLeaderPermission($permission)
    {
        // 超级管理员拥有所有权限
        if (self::isSuperAdmin()) {
            return true;
        }

        if ($permission !== 'create') {
            return false;
        }

        return self::checkDataAuthPermission('department_leader_create_customer');
    }

    /**
     * 增强版权限检查：结合原有权限和 oa_data_auth 配置
     * @param string $table 表名
     * @param int $dataId 数据ID（为0时表示检查创建权限）
     * @param array $options 权限选项
     * @return bool
     */
    public static function checkDataAccessEnhanced($table, $dataId, $options = [])
    {
        // 先检查特殊权限（oa_data_auth）
        if ($table === 'customer') {
            // 检查查看权限
            if ($dataId > 0) {
                // 1. 检查法务部门查看权限
                if (self::hasLegalDepartmentPermission('view')) {
                    return true;
                }
            }

            // 检查编辑权限
            if (isset($options['check_edit']) && $options['check_edit']) {
                if (self::hasLegalDepartmentPermission('edit')) {
                    return true;
                }
            }

            // 检查创建权限
            if (isset($options['check_leader']) && $options['check_leader']) {
                if (self::hasLegalDepartmentPermission('create') || self::hasDepartmentLeaderPermission('create')) {
                    return true;
                }
            }
        }

        // 2. 使用原有权限系统
        if ($dataId > 0) {
            return self::checkDataAccess($table, $dataId, $options);
        }

        return false;
    }

    /**
     * 构建客户数据权限查询条件（增强版）
     * 集成 oa_data_auth 特殊权限检查
     * @param array $baseWhere 基础查询条件
     * @param array $options 权限选项
     * @return array
     */
    public static function buildCustomerDataWhere($baseWhere = [], $options = [])
    {
        // 如果用户有法务部门查看所有权限，不应用权限过滤（返回基础条件）
        if (self::hasLegalDepartmentPermission('view')) {
            return $baseWhere;
        }

        // 客户表没有 check_uids 字段，不使用审批权限
        $defaultOptions = [
            'personal' => true,
            'department' => true,
            'shared' => true,
            'approval' => false,  // 客户表没有审批字段
            'creator' => true
        ];
        $options = array_merge($defaultOptions, $options);

        // 使用原有的综合权限条件
        return self::buildComprehensiveDataWhere($baseWhere, $options);
    }

    /**
     * 为新创建的数据设置权限字段
     * @param array $data 数据数组
     * @param array $options 选项
     * @return array
     */
    public static function setDataPermissionFields($data, $options = [])
    {
        $userId = self::getCurrentUserId();
        $permissions = self::getCurrentUserPermissions();

        if ($userId <= 0 || !$permissions) {
            return $data;
        }

        // 设置数据创建者
        if (!isset($data['belong_uid'])) {
            $data['belong_uid'] = $userId;
        }

        // 设置数据所属部门
        if (!isset($data['belong_did']) && $permissions['department_id'] > 0) {
            $data['belong_did'] = $permissions['department_id'];
        }

        // 设置创建时间和更新时间
        if (!isset($data['create_time'])) {
            $data['create_time'] = time();
        }
        $data['update_time'] = time();

        return $data;
    }
}